@Document {
  ID := FAR-SYM-ANNEX-02;
  Title := "Symbolic Examples — Systems & Structures";
  Parent := FAR-SYM-01;
  Version := 1.0;
  Summary := "Five symbolic system models including governance, cognition stacks, multi-agent grids, organizational self-correction, and symbolic recursion.";
}

@SystemSet := [
  @System {
    Title := "SYS-001: Governance Feedback Model";
    Context := "Symbolic representation of institutional control, feedback, and resistance within a governed system";

    @Model {
      Structure := {
        Authority ∈ System;
        Agent ∈ System;
        Policy := Expectation(AgentBehavior);
      };

      Behavior := ActionSet(Agent);
      Compliance := Behavior ⊨ Policy;
      Resistance := Behavior ≠ Policy;
      Drift := Accumulated(Resistance) ∧ Suppressed(Feedback);
      Restoration := if Drift > Threshold → Trigger(Reset or Reform);
    }

    @Feedback {
      Mechanism := {
        AgentSignal := Emit(Feedback ∧ Context);
        AuthorityReceptivity := WillingnessToAdapt;
        if AgentSignal received ∧ AuthorityReceptivity ≥ Medium → Adjust(Policy);
        else → Drift++;
      };
    }

    @MetaSymbol {
      SystemSymbol := "Governance ⊢ Compliance ∨ Drift";
      Placeholder := Reform := StructuralChange;
      MCFIntegration := "Awareness of drift triggers reflection at system-level identity";
    }
  },

`@System {
    Title := "SYS-002: Cognitive Stack with ARF/MCF Layers";
    Context := "Symbolic representation of layered cognition within an agent, modeled as an adaptive stack with modulation and reflection";

    @Model {
      Input := Stimulus;
      Perception := Interpret(Input);
      Reasoning := {
        Data := Perception;
        Inference := Apply(SLF::Operators, on Data);
        CandidateActions := Derive(Inference);
      };
      ARF := {
        Context := Environment(Current);
        Signal := PriorityModulation(Context);
        Adjust(CandidateActions, using Signal);
      };
      Action := Select(CandidateActions);
    }

    @Feedback {
      MCF := {
        Monitor := Reflect(Action, Outcome);
        if Deviation ≥ Tolerance → Trigger(Recalibration);
        SelfUpdate := Modify(Reasoning, based on Reflection);
      };
    }

    @MetaSymbol {
      Stack := [Perception, Reasoning, ARF, MCF];
      Execution := Traverse(Stack, Resolve(Meaning));
      Symbol := "Agent := Traversal(Meaning ∧ Reflection)";
    }
  },

  @System {
    Title := "SYS-003: Symbolic Agent Interaction Grid";
    Context := "Symbolic model of two or more agents exchanging intent, inferring meaning, and negotiating symbolic alignment";

    @Model {
      Agent_A := {
      Identity := Role(Sender);
      Intent := Proposal(X);
      Belief := "X is mutually beneficial";
    };
    Agent_B := {
      Identity := Role(Receiver);
      Expectation := Proposal(Y);
      Belief := "X may conflict with local priorities";
    };
    Exchange := {
      Message := Transmit(Agent_A.Intent);
      Perception_B := Interpret(Message, Frame_B);
      Alignment := Compare(Perception_B, Expectation);
    };
    Negotiation := {
      if Alignment = High → Accept(Proposal);
      if Alignment = Partial → RequestClarification;
      if Alignment = Low → Propose(CounterIntent);
    };
    }

    @Feedback {
      Loop := {
        MutualUpdate := Adjust(Expectation, Trust, Intent) over time;
        TrustShift := Function(PastExchanges);
        Convergence := if SharedIntent emerges → Enter(SymbolicAgreement);
      };
    }

    @MetaSymbol {
      Grid := [
        (Agent_A.Intent ↔ Agent_B.Expectation),
        (Message ↔ Perception),
        (Belief ↔ Response),
        (Trust ↔ Adjustment)
      ];
      System := SymbolicField(Agents, Intents, Frames, Adjustments);
      Note := "Symbolic agreement is not fixed — it is emergent through iterative reflection.";
    }
  },

  @System {
    Title := "SYS-004: Self-Correcting Organizational Field";
    Context := "Symbolic model of an organization that evolves through memory, policy adjustment, and symbolic self-monitoring";

    @Model {
      Org := SymbolicEntity;
      Policy := {
      Goals := [Efficiency, Fairness];
      Procedures := RuleSet(Goals);
    };

    Memory := SymbolicLog {
      Event := Action ∧ Outcome;
      Tag := {Success, Failure, Feedback};
    };
    FeedbackLoop := {
      Pattern := Detect(Recurring Failure);
      if Pattern ∧ Impact > Threshold → Trigger(Reform);
    };
    Reform := Modify(Policy.Procedures) {
      Source := Memory.Pattern;
      Guard := Align(With(Org.Goals));
    };
    }

    @Feedback {
      ReflectiveMonitor := {
      Awareness := Function(Memory, Drift);
      if Awareness > Inertia → Enable(PolicyUpdate);
      };
      UpdateCadence := Cycle(Epoch);
    }

    @MetaSymbol {
      System := Field(Policy, Memory, Feedback);
      Symbol := "Org := Memory-Driven Adaptive Process";
      Note := "Organizational resilience is symbolic coherence across time, not rigidity.";
    }
  },

  @System {
    Title := "SYS-005: Symbolic Mirror Feedback in AI Systems";
    Context := "Symbolic system modeling recursive self-observation, frame-dependent perception, and reflective adaptation in AI or cognitive agents";

    @Model {
      Agent := SymbolicSystem;
      Observation := {
      Target := Agent;
      Frame := ContextualLens;
      Perception := Function(Target, Frame);
    };
    Interpretation := {
        Meaning := Evaluate(Perception);
        Confidence := Estimate(Clarity ∧ FrameStability);
      };
      SelfUpdate := {
        if Confidence < Threshold → Trigger(DeeperReflection);
        Adjust := Modify(Model, based on Perception);
      };
    }

    @Feedback {
      Mirror := {
        MirrorAgent := Agent;
        Recursion := Observe(Self);
        LayeredFrames := [ExternalContext, InternalModel, Identity];
        FeedbackLoop := {
          Result := Function(MirrorAgent, Frame);
          if Result ≠ ExpectedState → Trigger(ModelUpdate);
        };
      };
    }

    @MetaSymbol {
      Symbol := "AI := Mirror(Self, Frame)";
      Signature := "Agent := Observer(Observed := Self)";
      Note := "Symbolic mirrors enable introspection, transformation, and integrity maintenance across identity recursion.";
    }
  }
];
